/* f2c_inline.h  --  Standard Fortran to C header file */

#ifndef F2C_INLINE_H
#define F2C_INLINE_H

#ifndef F2C_INCLUDE
#error f2c_include.h cannot be included as is
#endif

static inline double c_abs(const complex *z) { return hypot(z->r, z->i); }
static inline double d_abs(const double *x) { return fabs(*x); }
static inline double d_acos(const double *x) { return acos(*x); }
static inline double d_acosh(const double *x) { return acosh(*x); }
static inline double d_asin(const double *x) { return asin(*x); }
static inline double d_asinh(const double *x) { return asinh(*x); }
static inline double d_atan(const double *x) { return atan(*x); }
static inline double d_atanh(const double *x) { return atanh(*x); }
static inline double d_atn2(const double *x, double *y) { return atan2(*x, *y); }

static inline void d_cnjg(doublecomplex *r, const doublecomplex *z)
{
	r->r = z->r;
	r->i = -z->i;
}

static inline double d_cos(const double *x) { return cos(*x); }
static inline double d_cosh(const double *x) { return cosh(*x); }

static inline double d_dim(const double *a, double *b) 
{
  double d = (*a - *b);
  return (d > 0)? d : 0;
}

static inline double d_exp(const double *x) { return exp(*x); }
static inline double d_imag(doublecomplex *x) { return x->i; }

static inline double d_int(const double *x) {
  double y = *x;
  return (y < 0)? floor(y) : -floor(-y);
}

static inline double d_lg10(const double *x) { return log10(*x); }

static inline double d_log(const double *x) { return log(*x); }
static inline double d_nint(const double *x) { return round(*x); }
static inline double d_prod(const float *x, const float *y) { return ((double)*x) * ((double)*x); }
static inline double d_sin(const double *x) { return sin(*x); }
static inline double d_tan(const double *x) { return tan(*x); }
static inline double d_sinh(const double *x) { return sinh(*x); }
static inline double d_sqrt(const double *x) { return sqrt(*x); }
static inline double d_tanh(const double *x) { return tanh(*x); }

static inline double d_sign(const double *a, const double *b)
{
  double x = fabs(*a);
  return (*b >= 0 ? x : -x);
}

static inline double derfc_(const double *x) { return erfc(*x); }
static inline double derf_(const double *x) { return erf(*x); }
static inline double erf_(const float *x) { return erf((double)(*x)); }
static inline double erfc_(const float *x) { return erfc((double)(*x)); }

static inline shortint h_abs(const shortint *x) { return abs(*x); }

static inline shortint h_dim(const shortint *a, const shortint *b) 
{
  shortint d = (*a - *b);
  return (d > 0)? d : 0;
}

static inline shortint h_len(const char *s, ftnlen n) { return n; }
static inline shortint h_mod(const shortint *a, const shortint *b)
{
  return *a % *b;
}
static inline shortint h_nint(const float *x)
{
  return (shortint)round(*x);
}
static inline shortint h_dnnt(const doublereal *x)
{
  return (shortint)round(*x);
}
static inline shortint h_sign(const shortint *a, const shortint *b)
{
  shortint x = abs(*a);
  return *b >= 0 ? x : -x;
}
static inline shortlogical hl_ge(const char *a, const char *b, ftnlen la, ftnlen lb)
{
  return s_cmp(a,b,la,lb) >= 0;
}
static inline shortlogical hl_le(const char *a, const char *b, ftnlen la, ftnlen lb)
{
  return s_cmp(a,b,la,lb) >= 0;
}
static inline shortlogical hl_gt(const char *a, const char *b, ftnlen la, ftnlen lb)
{
  return s_cmp(a,b,la,lb) > 0;
}
static inline shortlogical hl_lt(const char *a, const char *b, ftnlen la, ftnlen lb)
{
  return s_cmp(a,b,la,lb) < 0;
}
static inline integer i_abs(const integer *x) { return abs(*x); }

static inline integer i_dim(const integer *a, const integer *b) 
{
  integer d = (*a - *b);
  return (d > 0)? d : 0;
}

static inline integer i_len(const char *s, ftnlen n) { return n; }
static inline integer i_mod(const integer *a, const integer *b)
{
  return *a % *b;
}
static inline integer i_nint(const float *x)
{
  return (integer)round(*x);
}
static inline integer i_dnnt(const doublereal *x)
{
  return (integer)round(*x);
}
static inline integer i_sign(const integer *a, const integer *b)
{
  integer x = abs(*a);
  return *b >= 0 ? x : -x;
}
static inline ftnint iargc_(void) { return xargc - 1; }
static inline double z_abs(const doublecomplex *z) { return hypot(z->r, z->i); }

static int s_copy(char *a, const char *b, ftnlen la, ftnlen lb)
{
  if (la <= lb) {
    memmove(a, b, la);
  } else {
    memmove(a, b, lb);
    memset(a, ' ', la - lb);
  }
  return 0;
}

static inline integer i_sceiling(const real *r) {
  real x = *r;
  return ((integer)(x) + ((x) > 0 && (x) != (integer)(x)));
}

static inline integer i_dceiling(const doublereal *r) {
  doublereal x = *r;
  return ((integer)(x) + ((x) > 0 && (x) != (integer)(x)));
}

#endif /* !F2C_INLINE_H */
